package core

import (
	"fmt"
	"strconv"
	"strings"

	"github.com/jroimartin/gocui"
)

// 1. 新增 isQuit 字段：标记用户是否通过Quit按钮/Ctrl+C退出
type config struct {
	interfaces     []map[string]string
	plugins        []string
	selectedIntf   int
	selectedPlugin int
	port           string
	focus          int  // 0: interfaces, 1: plugins, 2: port, 3: start button, 4: quit button
	isQuit         bool // 关键标记：true=用户主动Quit，false=用户选择Start
}

func runTUI(interfaces []map[string]string, plugins []string) (string, string, int) {
	g, err := gocui.NewGui(gocui.OutputNormal)
	if err != nil {
		fmt.Printf("Error creating GUI: %v\n", err)
		return "", "", 0
	}
	defer g.Close()

	// 2. 初始化时默认 isQuit=false（未退出状态）
	cfg := &config{
		interfaces:     interfaces,
		plugins:        plugins,
		selectedIntf:   0,
		selectedPlugin: 0,
		port:           "12345",
		focus:          0,
		isQuit:         false, // 初始值：未退出
	}

	g.SetManagerFunc(func(g *gocui.Gui) error {
		return layout(g, cfg)
	})

	// 3. 传入 cfg 到键绑定函数（用于修改 isQuit 标记）
	if err := setKeybindings(g, cfg); err != nil {
		fmt.Printf("Error setting keybindings: %v\n", err)
		return "", "", 0
	}

	g.Cursor = true
	g.SelFgColor = gocui.ColorGreen
	g.Highlight = true

	// 4. 主循环：无论Quit还是Start，都会通过 gocui.ErrQuit 退出循环
	if err := g.MainLoop(); err != nil && err != gocui.ErrQuit {
		fmt.Printf("Error in main loop: %v\n", err)
		return "", "", 0
	}

	// 5. 核心判定：若用户是Quit退出（isQuit=true），直接返回空值，跳过后续参数校验
	if cfg.isQuit {
		fmt.Println("Exiting Go-Sniffer (user quit)") // 可选：打印退出提示
		return "", "", 0
	}

	// 6. 只有用户选择Start（isQuit=false），才执行参数校验和返回
	// 转换端口为整数（增加错误处理，避免无效端口导致崩溃）
	port, err := strconv.Atoi(cfg.port)
	if err != nil {
		fmt.Printf("Invalid port number: %v\n", err)
		return "", "", 0
	}
	if cfg.selectedIntf < 0 || cfg.selectedIntf >= len(interfaces) {
		return "", "", 0
	}
	if cfg.selectedPlugin < 0 || cfg.selectedPlugin >= len(plugins) {
		return "", "", 0
	}

	return interfaces[cfg.selectedIntf]["name"], plugins[cfg.selectedPlugin], port
}

// layout 函数无修改，保留原逻辑
func layout(g *gocui.Gui, cfg *config) error {
	maxX, maxY := g.Size()

	// 定义主窗口大小和位置
	windowWidth := 80
	windowHeight := 28
	startX := (maxX - windowWidth) / 2
	startY := (maxY - windowHeight) / 2

	// 创建主窗口边框
	if v, err := g.SetView("main", startX, startY, startX+windowWidth, startY+windowHeight); err != nil {
		if err != gocui.ErrUnknownView {
			return err
		}
		v.Title = " Go-Sniffer Configuration "
		v.Frame = true
	}

	// 标题
	if v, err := g.SetView("title", startX+windowWidth/2-15, startY+1, startX+windowWidth/2+15, startY+3); err != nil {
		if err != gocui.ErrUnknownView {
			return err
		}
		v.Frame = false
		v.BgColor = gocui.ColorDefault
		v.FgColor = gocui.ColorYellow
		fmt.Fprintf(v, "🐛 Go-Sniffer Configuration")
	}

	// 网络接口列表
	intfViewHeight := 10
	if v, err := g.SetView("interfaces", startX+5, startY+5, startX+windowWidth-5, startY+5+intfViewHeight); err != nil {
		if err != gocui.ErrUnknownView {
			return err
		}
		v.Title = "Network Interfaces "
		v.Highlight = true
		v.SelBgColor = gocui.ColorBlue
		v.SelFgColor = gocui.ColorWhite
		v.Wrap = false
		v.Autoscroll = false

		fmt.Fprintf(v, "%-12s %-18s %-15s\n", "Interface", "MAC Address", "IP Address")
		fmt.Fprintf(v, "%-12s %-18s %-15s\n", "──────────", "──────────────────", "───────────────")

		for _, intf := range cfg.interfaces {
			name := intf["name"]
			if len(name) > 10 {
				name = name[:10] + "..."
			}
			mac := intf["mac"]
			if len(mac) > 17 {
				mac = mac[:17]
			}
			ip := intf["ip"]
			if len(ip) > 14 {
				ip = ip[:14] + "..."
			}
			fmt.Fprintf(v, " %-12s %-18s %-15s\n", name, mac, ip)
		}

		if len(cfg.interfaces) > 0 {
			fmt.Fprintf(v, "\nTotal: %d interface(s)", len(cfg.interfaces))
		}

		// 设置光标到第一个网络接口行（跳过两行表头）
		if len(cfg.interfaces) > 0 {
			v.SetCursor(0, 2) // 第0列，第2行（跳过表头）
		}
	}

	// 插件列表
	pluginViewHeight := 6
	if v, err := g.SetView("plugins", startX+5, startY+16, startX+windowWidth-5, startY+16+pluginViewHeight); err != nil {
		if err != gocui.ErrUnknownView {
			return err
		}
		v.Title = "Database Plugins "
		v.Highlight = true
		v.SelBgColor = gocui.ColorGreen
		v.SelFgColor = gocui.ColorBlack
		for _, plugin := range cfg.plugins {
			fmt.Fprintf(v, " %s\n", plugin)
		}

		// 设置光标到第一个插件
		if len(cfg.plugins) > 0 {
			v.SetCursor(0, 0)
		}
	}

	// 端口输入（优化：光标默认定位到文本末尾）
	portY := startY + 23
	if v, err := g.SetView("port", startX+5, portY, startX+20, portY+2); err != nil {
		if err != gocui.ErrUnknownView {
			return err
		}
		v.Title = "Port "
		v.Editable = true
		fmt.Fprint(v, cfg.port)
		// 光标初始位置设为文本末尾
		v.SetCursor(len(cfg.port), 0)
	}

	// 为每个按钮创建单独的View
	buttonsY := portY
	// Start按钮
	if v, err := g.SetView("start_button", startX+25, buttonsY, startX+50, buttonsY+2); err != nil {
		if err != gocui.ErrUnknownView {
			return err
		}
		v.Highlight = true
		v.SelBgColor = gocui.ColorGreen
		v.SelFgColor = gocui.ColorBlack
		fmt.Fprintf(v, "🚀 Start Sniffing")
	}

	// Quit按钮
	if v, err := g.SetView("quit_button", startX+55, buttonsY, startX+75, buttonsY+2); err != nil {
		if err != gocui.ErrUnknownView {
			return err
		}
		v.Highlight = true
		v.SelBgColor = gocui.ColorRed
		v.SelFgColor = gocui.ColorWhite
		fmt.Fprintf(v, "❌ Quit")
	}

	// 设置当前焦点视图
	return setCurrentView(g, cfg.focus)
}

// setCurrentView 函数无修改，保留原逻辑
func setCurrentView(g *gocui.Gui, focus int) error {
	views := []string{"interfaces", "plugins", "port", "start_button", "quit_button"}

	if focus < 0 || focus >= len(views) {
		return nil
	}

	// 设置当前视图
	if _, err := g.SetCurrentView(views[focus]); err != nil {
		return err
	}

	// 确保视图在顶部
	if _, err := g.SetViewOnTop(views[focus]); err != nil {
		return err
	}

	// 根据焦点设置光标状态（Port视图显示光标，其他视图隐藏）
	if focus == 2 { // port 视图需要光标
		g.Cursor = true
	} else {
		g.Cursor = false
	}

	return nil
}

// nextView 函数无修改，保留原逻辑
func nextView(g *gocui.Gui, cfg *config) error {
	cfg.focus = (cfg.focus + 1) % 5 // 5个视图循环切换
	return setCurrentView(g, cfg.focus)
}

// prevView 函数无修改，保留原逻辑
func prevView(g *gocui.Gui, cfg *config) error {
	cfg.focus = (cfg.focus + 4) % 5 // 等效于减1（避免负数）
	return setCurrentView(g, cfg.focus)
}

// 7. 关键修改：重写键绑定逻辑，区分 Quit/Start 操作（修改 isQuit 标记）
func setKeybindings(g *gocui.Gui, cfg *config) error {
	// 定义 Quit 操作的处理函数：标记 isQuit=true，再退出主循环
	handleQuit := func(g *gocui.Gui, v *gocui.View) error {
		cfg.isQuit = true    // 用户主动Quit，标记为true
		return gocui.ErrQuit // 触发主循环退出
	}

	// 定义 Start 操作的处理函数：标记 isQuit=false，再退出主循环
	handleStart := func(g *gocui.Gui, v *gocui.View) error {
		// 保存端口输入（避免用户修改后丢失）
		if portView, err := g.View("port"); err == nil {
			cfg.port = strings.TrimSpace(portView.Buffer())
		}
		cfg.isQuit = false   // 用户选择Start，标记为false
		return gocui.ErrQuit // 触发主循环退出
	}

	// 1. 全局退出绑定（Ctrl+C）：触发 Quit 操作
	if err := g.SetKeybinding("", gocui.KeyCtrlC, gocui.ModNone, handleQuit); err != nil {
		return err
	}

	// 2. 仅保留Tab键切换焦点（向前）
	if err := g.SetKeybinding("", gocui.KeyTab, gocui.ModNone, func(g *gocui.Gui, v *gocui.View) error {
		return nextView(g, cfg)
	}); err != nil {
		return err
	}

	// 移除Backspace键的反向切换功能（如需保留可注释此行）
	// if err := g.SetKeybinding("", gocui.KeyBackspace, gocui.ModNone, func(g *gocui.Gui, v *gocui.View) error {
	// 	return prevView(g, cfg)
	// }); err != nil {
	// 	return err
	// }

	// 3. 网络接口列表 - 上下键导航（保留上下键功能，移除左右键焦点切换）
	if err := g.SetKeybinding("interfaces", gocui.KeyArrowDown, gocui.ModNone, func(g *gocui.Gui, v *gocui.View) error {
		if cfg.selectedIntf < len(cfg.interfaces)-1 {
			cfg.selectedIntf++
			if v != nil {
				cx, cy := v.Cursor()
				if cy >= 1 && cy < len(cfg.interfaces)+1 {
					v.MoveCursor(cx, 1, false)
				}
			}
		}
		return nil
	}); err != nil {
		return err
	}

	if err := g.SetKeybinding("interfaces", gocui.KeyArrowUp, gocui.ModNone, func(g *gocui.Gui, v *gocui.View) error {
		if cfg.selectedIntf > 0 {
			cfg.selectedIntf--
			if v != nil {
				cx, cy := v.Cursor()
				if cy > 2 {
					v.MoveCursor(cx, -1, false)
				}
			}
		}
		return nil
	}); err != nil {
		return err
	}

	// 4. 插件列表 - 上下键导航（保留上下键功能，移除左右键焦点切换）
	if err := g.SetKeybinding("plugins", gocui.KeyArrowDown, gocui.ModNone, func(g *gocui.Gui, v *gocui.View) error {
		if cfg.selectedPlugin < len(cfg.plugins)-1 {
			cfg.selectedPlugin++
			if v != nil {
				cx, cy := v.Cursor()
				if cy < len(cfg.plugins)-1 {
					v.MoveCursor(cx, 1, false)
				}
			}
		}
		return nil
	}); err != nil {
		return err
	}

	if err := g.SetKeybinding("plugins", gocui.KeyArrowUp, gocui.ModNone, func(g *gocui.Gui, v *gocui.View) error {
		if cfg.selectedPlugin > 0 {
			cfg.selectedPlugin--
			if v != nil {
				cx, cy := v.Cursor()
				if cy > 0 {
					v.MoveCursor(cx, -1, false)
				}
			}
		}
		return nil
	}); err != nil {
		return err
	}

	// 5. Port视图 - Enter键（保存端口并切换到下一个视图）
	if err := g.SetKeybinding("port", gocui.KeyEnter, gocui.ModNone, func(g *gocui.Gui, v *gocui.View) error {
		if v != nil {
			cfg.port = strings.TrimSpace(v.Buffer())
		}
		return nextView(g, cfg)
	}); err != nil {
		return err
	}

	// 6. Port视图 - 左右键（仅保留光标移动功能，不涉及焦点切换）
	if err := g.SetKeybinding("port", gocui.KeyArrowLeft, gocui.ModNone, func(g *gocui.Gui, v *gocui.View) error {
		if v != nil {
			cx, _ := v.Cursor()
			if cx > 0 {
				v.MoveCursor(-1, 0, false)
			}
		}
		return nil
	}); err != nil {
		return err
	}

	if err := g.SetKeybinding("port", gocui.KeyArrowRight, gocui.ModNone, func(g *gocui.Gui, v *gocui.View) error {
		if v != nil {
			cx, _ := v.Cursor()
			text := v.Buffer()
			if cx < len(text) {
				v.MoveCursor(1, 0, false)
			}
		}
		return nil
	}); err != nil {
		return err
	}

	// 7. Start按钮 - Enter键：触发 Start 操作（保存端口+标记isQuit=false）
	if err := g.SetKeybinding("start_button", gocui.KeyEnter, gocui.ModNone, handleStart); err != nil {
		return err
	}

	// 8. Quit按钮 - 快捷键：触发 Quit 操作（标记isQuit=true）
	if err := g.SetKeybinding("quit_button", gocui.KeyEnter, gocui.ModNone, handleQuit); err != nil {
		return err
	}
	if err := g.SetKeybinding("quit_button", 'q', gocui.ModNone, handleQuit); err != nil {
		return err
	}

	// 移除所有左右键的焦点切换绑定（包括按钮间的快速切换）
	// 注释掉原有的左右键切换逻辑，确保左右键不会移动焦点

	return nil
}

// 原 quit 函数已被 handleQuit 替代，可删除或注释（避免未使用警告）
// func quit(g *gocui.Gui, v *gocui.View) error {
// 	return gocui.ErrQuit
// }
